#include "elementsGenerique.H"
#include <cstdio>
#include <stdio.h>

void initialisationEltIntervalle(Element & e1)
{
  e1 = new Intervalle;
  ((Intervalle*)e1)->inf = 0;
  ((Intervalle*)e1)->sup = 0;
}

void initialisationEltIntervalle(Element & e1,Element e2)
{
  e1 = new Intervalle;
  affectationIntervalle(e1, e2);
}

int plusPetitIntervalle(Element e1, Element e2)
{
  return ( ((Intervalle*)e1)->sup < ((Intervalle*)e2)->sup );
}

int egalIntervalle (Element e1, Element e2)
{
  return ( (((Intervalle*)e1)->sup == ((Intervalle*)e2)->sup) &&
	   (((Intervalle*)e1)->inf == ((Intervalle*)e2)->inf) );
}

int compareIntervalle (Element e1, Element e2)
{
  return ((Intervalle*)e1)->sup - ((Intervalle*)e2)->sup;
}

void testamentIntervalle (Element& e)
{
  delete (Intervalle*)e;
  e = NULL;
}

/*Precondition e1 initialise et e2 de type effectif intervalle.
 * Postcondition : e1 = e2 avec e2 adresse de son clone.
 */
void affectationIntervalle(Element &e1, Element e2)
{
  if(e1 != e2)
    {
      ((Intervalle *)e1)->inf = ((Intervalle *)e2)->inf;
      ((Intervalle *)e1)->sup = ((Intervalle *)e2)->sup;
    }
}

/*Precondition e1 initialise et e2 de type effectif intervalle.
 * Postcondition : e1 = e2 avec e2 adresse de son clone.
 */
void affectationIntervalle(Element &e1, int i, int j)
{
  ((Intervalle *)e1)->inf = i;
  ((Intervalle *)e1)->sup = j;
}

void afficherIntervalle(Element e)
{
  printf("[%d,%d]", ((Intervalle*)e)->inf, ((Intervalle*)e)->sup);
}

/**TYPE EFFECTIF INT**/
/*precondition : e2 adresse d'une variable de type int
  postcondition : e1 de type effectif int
				  clone de l'element correspondant à e2
*/
void initialisationEltInt(Element & e1,Element e2)
{
	int * itmp = (int *)e2;
	e1 = new int;
	*(int*)e1 = *itmp;
}

int compareInt(Element e1, Element e2)
{
	return *((int*)e1) - *((int*)e2);
}


/*Precondition e1 initialise et e2 de type effectif int.
 * Postcondition : e1 = e2 avec e2 adresse de son clone.
 */
void affectationInt(Element &e1, Element e2)
{
	if(e1 != e2)
	{
		*(int *)e1 = *(int *)e2;
	}
}


void afficherInt(Element e)
{
	std::printf("%d",*(int *)e);
}

void testamentInt(Element &e)
{
	delete (int*)e;
	e = NULL;
}
	
/*precondition : e initialise de type effectif int.
 *postcondition : e supprime du tas.
 */

/**TYPE EFFECTIF COMPLEXE**/
/*precondition : e2 initialise de type effectif complexe
				 ou bien e2 adresse d'une variable de type complexe
  postcondition : e1 de type effectif complexe                 
				  clone de l'element correspondant à e2
*/
void initialisationEltComplexe(Element & e1,Element e2)
{	
	e1 = new Complexe;
	Complexe * ctmp = (Complexe *) e2;
	initialisation(*(Complexe*)e1,*ctmp);
}
/*Precondition e1 initialise et e2 de type effectif int.
 * Postcondition : e1 = e2 avec e2 adresse de son clone.
 */
void affectationComplexe(Element &e1, Element e2)
{
  if(e1 != e2)
  {
    affectation(*(Complexe*)e1,*(Complexe*)e2);
  }
}


void afficherComplexe(Element e)
{
  Complexe * c = (Complexe*)e;
  affiche(*c);
}

/*precondition : e initialise de type effectif int.
 *postcondition : e supprime du tas.
 */
void testamentComplexe(Element &e)
{
  testament(*(Complexe*)e);
  delete (Complexe*)e;
  e = NULL;
}
